పైథాన్ ఫాస్ట్ఎపిఐ ఎర్రర్ హ్యాండ్లింగ్: రోబస్ట్ కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లను నిర్మించడం

బలమైన మరియు విశ్వసనీయమైన APIలను నిర్మించడంలో ఎర్రర్ హ్యాండ్లింగ్ ఒక కీలకమైన అంశం. పైథాన్ యొక్క ఫాస్ట్ఎపిఐలో, మీరు లోపాలను సున్నితంగా నిర్వహించడానికి మరియు క్లయింట్‌లకు సమాచార స్పందనలను అందించడానికి కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లను ఉపయోగించుకోవచ్చు. ఈ బ్లాగ్ పోస్ట్, ఫాస్ట్ఎపిఐలో కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లను సృష్టించే ప్రక్రియ ద్వారా మిమ్మల్ని మార్గనిర్దేశం చేస్తుంది, మరింత స్థితిస్థాపకంగా మరియు యూజర్-ఫ్రెండ్లీ అప్లికేషన్‌లను రూపొందించడానికి మీకు వీలు కల్పిస్తుంది.

కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లు ఎందుకు?

ఫాస్ట్ఎపిఐ ఎక్సెప్షన్స్‌ను హ్యాండిల్ చేయడానికి అంతర్నిర్మిత మద్దతును అందిస్తుంది. అయితే, డిఫాల్ట్ ఎర్రర్ స్పందనలపై మాత్రమే ఆధారపడటం క్లయింట్‌లకు అస్పష్టమైన లేదా సహాయం లేని సమాచారంతో వదిలివేయవచ్చు. కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లు అనేక ప్రయోజనాలను అందిస్తాయి:

• మెరుగైన యూజర్ అనుభవం: నిర్దిష్ట ఎర్రర్ దృశ్యాలకు అనుగుణంగా స్పష్టమైన మరియు సమాచార ఎర్రర్ సందేశాలను అందించండి.
• కేంద్రీకృత ఎర్రర్ నిర్వహణ: మీ కోడ్‌ను మరింత నిర్వహించగలిగేలా ఒకే చోట ఎర్రర్ హ్యాండ్లింగ్ లాజిక్‌ను ఏకీకృతం చేయండి.
• స్థిరమైన ఎర్రర్ స్పందనలు: API వినియోగాన్ని మెరుగుపరిచే స్థిరమైన ఫార్మాట్‌ను ఎర్రర్ స్పందనలు అనుసరించేలా చూసుకోండి.
• మెరుగైన భద్రత: ఎర్రర్ సందేశాలలో సున్నితమైన సమాచారం బహిర్గతం కాకుండా నిరోధించండి.
• కస్టమ్ లాగింగ్: డీబగ్గింగ్ మరియు పర్యవేక్షణ ప్రయోజనాల కోసం వివరణాత్మక ఎర్రర్ సమాచారాన్ని లాగ్ చేయండి.

ఫాస్ట్ఎపిఐ యొక్క ఎక్సెప్షన్ హ్యాండ్లింగ్‌ను అర్థం చేసుకోవడం

ఫాస్ట్ఎపిఐ పైథాన్ యొక్క అంతర్నిర్మిత ఎక్సెప్షన్ హ్యాండ్లింగ్ విధానాలు మరియు ఎర్రర్‌లను నిర్వహించడానికి దాని స్వంత డిపెండెన్సీ ఇంజెక్షన్ సిస్టమ్ కలయికను ఉపయోగిస్తుంది. ఒక రూట్ లేదా డిపెండెన్సీలో ఒక ఎక్సెప్షన్ పెరిగినప్పుడు, ఫాస్ట్ఎపిఐ దాన్ని ప్రాసెస్ చేయడానికి తగిన ఎక్సెప్షన్ హ్యాండ్లర్ కోసం శోధిస్తుంది.

ఎక్సెప్షన్ హ్యాండ్లర్‌లు @app.exception_handler()తో డెకరేట్ చేయబడిన ఫంక్షన్‌లు, అవి ఎక్సెప్షన్ రకం మరియు రిక్వెస్ట్ ఆబ్జెక్ట్ అనే రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటాయి. హ్యాండ్లర్ తగిన HTTP స్పందనను తిరిగి ఇవ్వడానికి బాధ్యత వహిస్తుంది.

కస్టమ్ ఎక్సెప్షన్స్‌ను సృష్టించడం

కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లను నిర్వచించడానికి ముందు, మీ అప్లికేషన్‌లోని నిర్దిష్ట ఎర్రర్ పరిస్థితులను సూచించే కస్టమ్ ఎక్సెప్షన్ క్లాస్‌లను సృష్టించడం తరచుగా ప్రయోజనకరంగా ఉంటుంది. ఇది కోడ్ రీడబిలిటీని మెరుగుపరుస్తుంది మరియు వివిధ రకాల ఎర్రర్‌లను హ్యాండిల్ చేయడాన్ని సులభతరం చేస్తుంది.

ఉదాహరణకు, మీరు ఒక ఇ-కామర్స్ APIని నిర్మిస్తున్నారని మరియు ఒక ఉత్పత్తి స్టాక్‌లో లేని సందర్భాలను హ్యాండిల్ చేయాలని అనుకుందాం. మీరు OutOfStockError అనే కస్టమ్ ఎక్సెప్షన్ క్లాస్‌ను నిర్వచించవచ్చు:

            
class OutOfStockError(Exception):
    def __init__(self, product_id: int):
        self.product_id = product_id
        self.message = f"Product with ID {product_id} is out of stock."

            

              
                Copy
              
            
          

ఈ కస్టమ్ ఎక్సెప్షన్ క్లాస్ బేస్ Exception క్లాస్ నుండి వారసత్వంగా వస్తుంది మరియు product_id అట్రిబ్యూట్ మరియు కస్టమ్ ఎర్రర్ మెసేజ్‌ను కలిగి ఉంటుంది.

కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లను అమలు చేయడం

ఇప్పుడు, OutOfStockError కోసం కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌ను సృష్టిద్దాం. ఈ హ్యాండ్లర్ ఎక్సెప్షన్‌ను క్యాచ్ చేసి, ఎర్రర్ మెసేజ్‌ను కలిగి ఉన్న JSON బాడీతో HTTP 400 (Bad Request) స్పందనను తిరిగి ఇస్తుంది.

            
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

class OutOfStockError(Exception):
    def __init__(self, product_id: int):
        self.product_id = product_id
        self.message = f"Product with ID {product_id} is out of stock."

@app.exception_handler(OutOfStockError)
async def out_of_stock_exception_handler(request: Request, exc: OutOfStockError):
    return JSONResponse(
        status_code=400,
        content={"message": exc.message},
    )

@app.get("/products/{product_id}")
async def get_product(product_id: int):
    # Simulate checking product stock
    if product_id == 123:
        raise OutOfStockError(product_id=product_id)
    return {"product_id": product_id, "name": "Example Product", "price": 29.99}

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, @app.exception_handler(OutOfStockError) డెకరేటర్ out_of_stock_exception_handler ఫంక్షన్‌ను OutOfStockError ఎక్సెప్షన్స్‌ను హ్యాండిల్ చేయడానికి నమోదు చేస్తుంది. get_product రూట్‌లో OutOfStockError పెరిగినప్పుడు, ఎక్సెప్షన్ హ్యాండ్లర్ పిలువబడుతుంది. హ్యాండ్లర్ 400 స్టేటస్ కోడ్ మరియు ఎర్రర్ మెసేజ్‌తో కూడిన JSON బాడీతో JSONResponseను తిరిగి ఇస్తుంది.

బహుళ ఎక్సెప్షన్ రకాలను హ్యాండిల్ చేయడం

వివిధ రకాల ఎక్సెప్షన్స్‌ను హ్యాండిల్ చేయడానికి మీరు బహుళ ఎక్సెప్షన్ హ్యాండ్లర్‌లను నిర్వచించవచ్చు. ఉదాహరణకు, మీరు యూజర్ ఇన్‌పుట్‌ను పార్స్ చేసేటప్పుడు సంభవించే ValueError ఎక్సెప్షన్స్‌ను హ్యాండిల్ చేయాలనుకోవచ్చు.

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_exception_handler(request: Request, exc: ValueError):
    return JSONResponse(
        status_code=400,
        content={"message": str(exc)},
    )

@app.get("/items/{item_id}")
async def get_item(item_id: int):
    # Simulate invalid item_id
    if item_id < 0:
        raise ValueError("Item ID must be a positive integer.")
    return {"item_id": item_id, "name": "Example Item"}

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, value_error_exception_handler ఫంక్షన్ ValueError ఎక్సెప్షన్స్‌ను హ్యాండిల్ చేస్తుంది. ఇది ఎక్సెప్షన్ ఆబ్జెక్ట్ నుండి ఎర్రర్ మెసేజ్‌ను సంగ్రహించి, దాన్ని JSON స్పందనలో తిరిగి ఇస్తుంది.

HTTPException ఉపయోగించడం

ఫాస్ట్ఎపిఐ HTTPException అనే అంతర్నిర్మిత ఎక్సెప్షన్ క్లాస్‌ను అందిస్తుంది, దీనిని HTTP-నిర్దిష్ట ఎర్రర్‌లను పెంచడానికి ఉపయోగించవచ్చు. అనధికార ప్రాప్యత లేదా వనరు కనుగొనబడలేదు వంటి సాధారణ ఎర్రర్ దృశ్యాలను హ్యాండిల్ చేయడానికి ఇది ఉపయోగకరంగా ఉంటుంది.

            
from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    # Simulate user not found
    if user_id == 999:
        raise HTTPException(status_code=404, detail="User not found")
    return {"user_id": user_id, "name": "Example User"}

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, HTTPException 404 (Not Found) స్టేటస్ కోడ్ మరియు డీటెయిల్ మెసేజ్‌తో పెంచబడింది. ఫాస్ట్ఎపిఐ స్వయంచాలకంగా HTTPException ఎక్సెప్షన్స్‌ను హ్యాండిల్ చేస్తుంది మరియు నిర్దిష్ట స్టేటస్ కోడ్ మరియు డీటెయిల్ మెసేజ్‌తో JSON స్పందనను తిరిగి ఇస్తుంది.

గ్లోబల్ ఎక్సెప్షన్ హ్యాండ్లర్స్

మీరు అన్ని హ్యాండిల్ చేయని ఎక్సెప్షన్స్‌ను క్యాచ్ చేసే గ్లోబల్ ఎక్సెప్షన్ హ్యాండ్లర్‌లను కూడా నిర్వచించవచ్చు. ఎర్రర్‌లను లాగ్ చేయడానికి లేదా క్లయింట్‌కు సాధారణ ఎర్రర్ మెసేజ్‌ను తిరిగి ఇవ్వడానికి ఇది ఉపయోగకరంగా ఉంటుంది.

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging

app = FastAPI()

logger = logging.getLogger(__name__)

@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    logger.exception(f"Unhandled exception: {exc}")
    return JSONResponse(
        status_code=500,
        content={"message": "Internal server error"},
    )

@app.get("/error")
async def trigger_error():
    raise ValueError("This is a test error.")

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, global_exception_handler ఫంక్షన్ ఇతర ఎక్సెప్షన్ హ్యాండ్లర్‌ల ద్వారా హ్యాండిల్ చేయని అన్ని ఎక్సెప్షన్స్‌ను హ్యాండిల్ చేస్తుంది. ఇది ఎర్రర్‌ను లాగ్ చేస్తుంది మరియు సాధారణ ఎర్రర్ మెసేజ్‌తో 500 (Internal Server Error) స్పందనను తిరిగి ఇస్తుంది.

మిడిల్‌వేర్ ఉపయోగించి ఎక్సెప్షన్ హ్యాండ్లింగ్

ఎక్సెప్షన్ హ్యాండ్లింగ్‌కు మరొక విధానం మిడిల్‌వేర్‌ను ఉపయోగించడం. మిడిల్‌వేర్ ఫంక్షన్‌లు ప్రతి రిక్వెస్ట్‌కు ముందు మరియు తర్వాత అమలు చేయబడతాయి, మిమ్మల్ని ఉన్నత స్థాయిలో ఎక్సెప్షన్స్‌ను అడ్డగించడానికి మరియు హ్యాండిల్ చేయడానికి అనుమతిస్తుంది. రిక్వెస్ట్‌లు మరియు స్పందనలను లాగ్ చేయడం లేదా కస్టమ్ ప్రామాణీకరణ లేదా అధికారిక లాజిక్‌ను అమలు చేయడం వంటి పనులకు ఇది ఉపయోగకరంగా ఉంటుంది.

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging

app = FastAPI()

logger = logging.getLogger(__name__)

@app.middleware("http")
async def exception_middleware(request: Request, call_next):
    try:
        response = await call_next(request)
    except Exception as exc:
        logger.exception(f"Unhandled exception: {exc}")
        return JSONResponse(
            status_code=500,
            content={"message": "Internal server error"},
        )
    return response

@app.get("/error")
async def trigger_error():
    raise ValueError("This is a test error.")

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, exception_middleware ఫంక్షన్ రిక్వెస్ట్ ప్రాసెసింగ్ లాజిక్‌ను try...except బ్లాక్‌లో చుట్టివేస్తుంది. రిక్వెస్ట్ ప్రాసెసింగ్ సమయంలో ఒక ఎక్సెప్షన్ పెరిగితే, మిడిల్‌వేర్ ఎర్రర్‌ను లాగ్ చేస్తుంది మరియు 500 (Internal Server Error) స్పందనను తిరిగి ఇస్తుంది.

ఉదాహరణ: ఇంటర్నేషనలైజేషన్ (i18n) మరియు ఎర్రర్ సందేశాలు

ప్రపంచవ్యాప్త ప్రేక్షకులకు APIలను నిర్మించేటప్పుడు, మీ ఎర్రర్ సందేశాలను ఇంటర్నేషనలైజ్ చేయడాన్ని పరిగణించండి. ఇది వినియోగదారు యొక్క లోకేల్ ఆధారంగా వివిధ భాషలలో ఎర్రర్ సందేశాలను అందించడాన్ని కలిగి ఉంటుంది. పూర్తి i18nను అమలు చేయడం ఈ కథనం పరిధికి మించినది అయితే, కాన్సెప్ట్‌ను ప్రదర్శించే సరళీకృత ఉదాహరణ ఇక్కడ ఉంది:

            
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse
from typing import Dict

app = FastAPI()

# Mock translation dictionary (replace with a real i18n library)
translations: Dict[str, Dict[str, str]] = {
    "en": {
        "product_not_found": "Product with ID {product_id} not found.",
        "invalid_input": "Invalid input: {error_message}",
    },
    "fr": {
        "product_not_found": "Produit avec l\'ID {product_id} introuvable.",
        "invalid_input": "Entrée invalide : {error_message}",
    },
    "es": {
        "product_not_found": "Producto con ID {product_id} no encontrado.",
        "invalid_input": "Entrada inválida: {error_message}",
    },
    "de": {
        "product_not_found": "Produkt mit ID {product_id} nicht gefunden.",
        "invalid_input": "Ungültige Eingabe: {error_message}",
    }
}

def get_translation(locale: str, key: str, **kwargs) -> str:
    """Retrieves a translation for a given locale and key.
    If the locale or key is not found, returns a default message.
    """
    if locale in translations and key in translations[locale]:
        return translations[locale][key].format(**kwargs)
    return f"Translation missing for key '{key}' in locale '{locale}'."

@app.get("/products/{product_id}")
async def get_product(request: Request, product_id: int, locale: str = "en"):
    # Simulate product lookup
    if product_id > 100:
        message = get_translation(locale, "product_not_found", product_id=product_id)
        raise HTTPException(status_code=404, detail=message)

    if product_id < 0:
         message = get_translation(locale, "invalid_input", error_message="Product ID must be positive")
         raise HTTPException(status_code=400, detail=message)

    return {"product_id": product_id, "name": "Example Product"}

            

              
                Copy
              
            
          

i18n ఉదాహరణకు ముఖ్యమైన మెరుగుదలలు:

• లోకేల్ పారామీటర్: రూట్ ఇప్పుడు locale క్వెరీ పారామీటర్‌ను అంగీకరిస్తుంది, క్లయింట్‌లు వారి ఇష్టపడే భాషను పేర్కొనడానికి అనుమతిస్తుంది (డిఫాల్ట్‌గా "en" ఇంగ్లీష్ కోసం).
• అనువాద డిక్షనరీ: translations డిక్షనరీ (మాక్) వివిధ లోకేల్స్ (ఈ సందర్భంలో ఇంగ్లీష్, ఫ్రెంచ్, స్పానిష్, జర్మన్) కోసం ఎర్రర్ సందేశాలను నిల్వ చేస్తుంది. వాస్తవ అప్లికేషన్‌లో, మీరు అంకితమైన i18n లైబ్రరీని ఉపయోగిస్తారు.
• get_translation ఫంక్షన్: ఈ సహాయక ఫంక్షన్ locale మరియు key ఆధారంగా తగిన అనువాదాన్ని పొందుతుంది. ఇది డైనమిక్ విలువలను (product_id వంటివి) చొప్పించడానికి స్ట్రింగ్ ఫార్మాటింగ్‌కు కూడా మద్దతు ఇస్తుంది.
• డైనమిక్ ఎర్రర్ సందేశాలు: HTTPException ఇప్పుడు get_translation ఫంక్షన్‌ను ఉపయోగించి డైనమిక్‌గా రూపొందించబడిన detail సందేశంతో పెంచబడింది.

ఒక క్లయింట్ /products/101?locale=frను అభ్యర్థించినప్పుడు, వారికి ఫ్రెంచ్ భాషలో ఎర్రర్ సందేశం (అనువాదం అందుబాటులో ఉంటే) వస్తుంది. /products/-1?locale=esను అభ్యర్థించినప్పుడు, వారికి స్పానిష్ భాషలో నెగటివ్ ID గురించి ఎర్రర్ సందేశం వస్తుంది (అందుబాటులో ఉంటే). /products/200?locale=xx (అనువాదాలు లేని లోకేల్)ను అభ్యర్థించినప్పుడు, వారికి `Translation missing` సందేశం వస్తుంది.

ఎర్రర్ హ్యాండ్లింగ్ కోసం ఉత్తమ పద్ధతులు

ఫాస్ట్ఎపిఐలో ఎర్రర్ హ్యాండ్లింగ్‌ను అమలు చేసేటప్పుడు గుర్తుంచుకోవలసిన కొన్ని ఉత్తమ పద్ధతులు ఇక్కడ ఉన్నాయి:

• కస్టమ్ ఎక్సెప్షన్స్‌ను ఉపయోగించండి: మీ అప్లికేషన్‌లోని నిర్దిష్ట ఎర్రర్ పరిస్థితులను సూచించడానికి కస్టమ్ ఎక్సెప్షన్ క్లాస్‌లను నిర్వచించండి.
• సమాచార ఎర్రర్ సందేశాలను అందించండి: క్లయింట్‌లు ఎర్రర్ కారణాన్ని అర్థం చేసుకోవడానికి సహాయపడే స్పష్టమైన మరియు సంక్షిప్త ఎర్రర్ సందేశాలను చేర్చండి.
• తగిన HTTP స్టేటస్ కోడ్‌లను ఉపయోగించండి: ఎర్రర్ స్వభావాన్ని ఖచ్చితంగా ప్రతిబింబించే HTTP స్టేటస్ కోడ్‌లను తిరిగి ఇవ్వండి. ఉదాహరణకు, చెల్లని ఇన్‌పుట్ కోసం 400 (Bad Request), కోల్పోయిన వనరుల కోసం 404 (Not Found), మరియు ఊహించని ఎర్రర్‌ల కోసం 500 (Internal Server Error) ఉపయోగించండి.
• సున్నితమైన సమాచారాన్ని బహిర్గతం చేయడం మానుకోండి: డేటాబేస్ ఆధారాలు లేదా API కీలు వంటి సున్నితమైన సమాచారాన్ని ఎర్రర్ సందేశాలలో బహిర్గతం చేయకుండా జాగ్రత్త వహించండి.
• ఎర్రర్‌లను లాగ్ చేయండి: డీబగ్గింగ్ మరియు పర్యవేక్షణ ప్రయోజనాల కోసం వివరణాత్మక ఎర్రర్ సమాచారాన్ని లాగ్ చేయండి. పైథాన్ యొక్క అంతర్నిర్మిత logging మాడ్యూల్ వంటి లాగింగ్ లైబ్రరీని ఉపయోగించండి.
• ఎర్రర్ హ్యాండ్లింగ్ లాజిక్‌ను కేంద్రీకరించండి: కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లు లేదా మిడిల్‌వేర్ వంటి ఒకే చోట ఎర్రర్ హ్యాండ్లింగ్ లాజిక్‌ను ఏకీకృతం చేయండి.
• మీ ఎర్రర్ హ్యాండ్లింగ్‌ను పరీక్షించండి: మీ ఎర్రర్ హ్యాండ్లింగ్ లాజిక్ సరిగ్గా పనిచేస్తుందని నిర్ధారించుకోవడానికి యూనిట్ టెస్ట్‌లను రాయండి.
• ప్రత్యేక ఎర్రర్ ట్రాకింగ్ సేవను పరిగణించండి: ప్రొడక్షన్ పరిసరాల కోసం, Sentry లేదా Rollbar వంటి ప్రత్యేక ఎర్రర్ ట్రాకింగ్ సేవను మీ అప్లికేషన్ ఆరోగ్యంపై విలువైన అంతర్దృష్టులను అందించడానికి మరియు సమస్యలను త్వరగా గుర్తించి పరిష్కరించడంలో మీకు సహాయపడటానికి పరిగణించండి.

ముగింపు

ఫాస్ట్ఎపిఐలో బలమైన మరియు యూజర్-ఫ్రెండ్లీ APIలను నిర్మించడానికి కస్టమ్ ఎక్సెప్షన్ హ్యాండ్లర్‌లు ఒక శక్తివంతమైన సాధనం. కస్టమ్ ఎక్సెప్షన్ క్లాస్‌లు మరియు హ్యాండ్లర్‌లను నిర్వచించడం ద్వారా, మీరు లోపాలను సున్నితంగా నిర్వహించవచ్చు, క్లయింట్‌లకు సమాచార స్పందనలను అందించవచ్చు మరియు మీ అప్లికేషన్ యొక్క మొత్తం విశ్వసనీయత మరియు నిర్వహణీయాన్ని మెరుగుపరచవచ్చు. కస్టమ్ ఎక్సెప్షన్స్, HTTPExceptions, మరియు వర్తించే చోట i18n సూత్రాలను ఉపయోగించడం కలయిక, మీ APIని ప్రపంచవ్యాప్త విజయానికి సిద్ధం చేస్తుంది.

మీ ఎర్రర్ హ్యాండ్లింగ్ వ్యూహాన్ని రూపొందించేటప్పుడు వినియోగదారు అనుభవాన్ని పరిగణించండి. సమస్యను మరియు దాన్ని ఎలా పరిష్కరించాలో అర్థం చేసుకోవడానికి వినియోగదారులకు సహాయపడే స్పష్టమైన మరియు సంక్షిప్త ఎర్రర్ సందేశాలను అందించండి. సమర్థవంతమైన ఎర్రర్ హ్యాండ్లింగ్ అనేది విస్తృతమైన ప్రపంచ ప్రేక్షకు అవసరాలను తీర్చే అధిక-నాణ్యత APIలను నిర్మించడానికి ఒక మూలస్తంభం.